// Package reflectx 提供了对Go标准reflect包的增强，
// 包括零拷贝类型缓存、高效字段访问和方法调用。
package refx

import (
	"fmt"
	"reflect"
	"sync"
	"unsafe"
)

// -----------------------------------------------------------------------------
// 类型缓存部分
// -----------------------------------------------------------------------------

// TypeInfo 存储类型的元信息
type TypeInfo struct {
	Type         reflect.Type
	Fields       map[string]*FieldInfo
	Methods      map[string]*MethodInfo
	PtrMethods   map[string]*MethodInfo
	IsPtr        bool
	ElemTypeInfo *TypeInfo // 如果是指针类型，则指向元素类型的TypeInfo
}

// FieldInfo 存储字段信息
type FieldInfo struct {
	Index        int
	Name         string
	Type         reflect.Type
	Offset       uintptr
	Anonymous    bool
	EmbeddedPath []int // 嵌套字段的路径
}

// MethodInfo 存储方法信息
type MethodInfo struct {
	Index      int
	Name       string
	Type       reflect.Type
	Func       unsafe.Pointer
	IsPtr      bool // 是否是指针接收器方法
	NumIn      int  // 参数数量（不包括接收器）
	NumOut     int  // 返回值数量
	IsVariadic bool // 是否是可变参数方法
}

var (
	typeCacheMu sync.RWMutex
	typeCache   = make(map[reflect.Type]*TypeInfo)
)

// GetTypeInfo 获取类型信息，如果缓存中没有则分析并缓存
func GetTypeInfo(t reflect.Type) *TypeInfo {
	// 先查找缓存
	typeCacheMu.RLock()
	info, ok := typeCache[t]
	typeCacheMu.RUnlock()

	if ok {
		return info
	}

	// 需要分析的类型列表（非递归方式）
	var typesToAnalyze []reflect.Type

	// 将当前类型加入列表
	currentType := t
	typesToAnalyze = append(typesToAnalyze, currentType)

	// 如果是指针类型，将元素类型也加入列表
	for currentType.Kind() == reflect.Ptr {
		elemType := currentType.Elem()
		typesToAnalyze = append(typesToAnalyze, elemType)
		currentType = elemType
	}

	// 查找这些类型中哪些需要被分析（不在缓存中）
	var unanalyzedTypes []reflect.Type
	typeCacheMu.RLock()
	for _, typ := range typesToAnalyze {
		if _, exists := typeCache[typ]; !exists {
			unanalyzedTypes = append(unanalyzedTypes, typ)
		}
	}
	typeCacheMu.RUnlock()

	// 如果没有需要分析的类型，返回缓存的结果
	if len(unanalyzedTypes) == 0 {
		typeCacheMu.RLock()
		info = typeCache[t]
		typeCacheMu.RUnlock()
		return info
	}

	// 获取写锁一次性分析所有类型（从最底层开始）
	typeCacheMu.Lock()
	defer typeCacheMu.Unlock()

	// 再次检查缓存，避免在获取锁期间被其他协程分析
	if info, ok = typeCache[t]; ok {
		return info
	}

	// 从最底层元素类型开始，逆序分析
	var typeInfoMap = make(map[reflect.Type]*TypeInfo)
	for i := len(unanalyzedTypes) - 1; i >= 0; i-- {
		typ := unanalyzedTypes[i]

		// 首先检查是否已在本次分析中创建
		if _, exists := typeInfoMap[typ]; exists {
			continue
		}

		// 再次检查缓存
		if info, ok = typeCache[typ]; ok {
			typeInfoMap[typ] = info
			continue
		}

		// 创建新的TypeInfo
		typeInfo := &TypeInfo{
			Type:       typ,
			Fields:     make(map[string]*FieldInfo),
			Methods:    make(map[string]*MethodInfo),
			PtrMethods: make(map[string]*MethodInfo),
			IsPtr:      typ.Kind() == reflect.Ptr,
		}

		// 如果是指针类型，设置元素类型信息
		if typeInfo.IsPtr {
			elemType := typ.Elem()
			// 使用已分析的元素类型信息
			if elemInfo, exists := typeInfoMap[elemType]; exists {
				typeInfo.ElemTypeInfo = elemInfo
			} else if elemInfo, exists := typeCache[elemType]; exists {
				typeInfo.ElemTypeInfo = elemInfo
			}

			// 分析指针指向结构体的字段
			if elemType.Kind() == reflect.Struct {
				analyzeFields(elemType, typeInfo, nil)
			}
		} else if typ.Kind() == reflect.Struct {
			// 直接分析结构体字段
			analyzeFields(typ, typeInfo, nil)
		}

		// 分析方法
		analyzeMethods(typ, typeInfo, false)

		// 如果不是指针类型，分析指针方法
		if !typeInfo.IsPtr {
			ptrType := reflect.PtrTo(typ)
			analyzeMethods(ptrType, typeInfo, true)
		}

		// 保存到映射和缓存
		typeInfoMap[typ] = typeInfo
		typeCache[typ] = typeInfo
	}

	// 返回原始类型的TypeInfo
	return typeInfoMap[t]
}

// analyzeFields 分析结构体字段，支持嵌套结构体
func analyzeFields(t reflect.Type, info *TypeInfo, embeddedPath []int) {
	numField := t.NumField()

	for i := 0; i < numField; i++ {
		field := t.Field(i)

		// 创建包含嵌入路径的副本
		currentPath := make([]int, len(embeddedPath), len(embeddedPath)+1)
		copy(currentPath, embeddedPath)
		currentPath = append(currentPath, i)

		// 计算字段偏移量
		var fieldOffset uintptr = field.Offset
		if len(embeddedPath) > 0 {
			// 添加嵌入结构体的偏移量
			for _, idx := range embeddedPath {
				if idx < t.NumField() {
					fieldOffset += t.Field(idx).Offset
				}
			}
		}

		// 创建字段信息
		fieldInfo := &FieldInfo{
			Index:        i,
			Name:         field.Name,
			Type:         field.Type,
			Offset:       fieldOffset,
			Anonymous:    field.Anonymous,
			EmbeddedPath: currentPath,
		}

		// 存储字段信息
		info.Fields[field.Name] = fieldInfo

		// 处理嵌入式结构体字段
		if field.Anonymous {
			embedType := field.Type
			// 如果是指针类型，获取元素类型
			if embedType.Kind() == reflect.Ptr {
				embedType = embedType.Elem()
			}

			// 只处理结构体类型的嵌入字段
			if embedType.Kind() == reflect.Struct {
				// 分析嵌入式结构体的字段
				for j := 0; j < embedType.NumField(); j++ {
					embedField := embedType.Field(j)

					// 排除非导出字段
					if embedField.PkgPath != "" {
						continue
					}

					// 计算嵌入字段的偏移量
					embedFieldOffset := fieldOffset + embedField.Offset

					// 创建嵌入字段的路径
					embedPath := make([]int, len(currentPath))
					copy(embedPath, currentPath)

					// 创建嵌入字段信息
					embedFieldInfo := &FieldInfo{
						Index:        j,
						Name:         embedField.Name,
						Type:         embedField.Type,
						Offset:       embedFieldOffset,
						Anonymous:    embedField.Anonymous,
						EmbeddedPath: append(embedPath, j),
					}

					// 只在不存在同名字段时添加
					if _, exists := info.Fields[embedField.Name]; !exists {
						info.Fields[embedField.Name] = embedFieldInfo
					}

					// 如果嵌入字段本身也是嵌入式结构体，递归处理
					if embedField.Anonymous && embedField.Type.Kind() == reflect.Struct {
						analyzeFields(embedField.Type, info, append(embedPath, j))
					}
				}
			}
		}
	}
}

// analyzeMethods 分析类型的方法
func analyzeMethods(t reflect.Type, info *TypeInfo, isPtr bool) {
	numMethod := t.NumMethod()

	for i := 0; i < numMethod; i++ {
		method := t.Method(i)

		methodInfo := &MethodInfo{
			Index:      i,
			Name:       method.Name,
			Type:       method.Type,
			Func:       unsafe.Pointer(method.Func.Pointer()),
			IsPtr:      isPtr,
			NumIn:      method.Type.NumIn() - 1, // 减去接收器参数
			NumOut:     method.Type.NumOut(),
			IsVariadic: method.Type.IsVariadic(),
		}

		if isPtr {
			info.PtrMethods[method.Name] = methodInfo
		} else {
			info.Methods[method.Name] = methodInfo
		}
	}
}

// GetTypeInfoFromValue 从值获取类型信息
func GetTypeInfoFromValue(v reflect.Value) *TypeInfo {
	return GetTypeInfo(v.Type())
}

// GetTypeInfoFromInterface 从接口值获取类型信息
func GetTypeInfoFromInterface(v interface{}) *TypeInfo {
	return GetTypeInfo(reflect.TypeOf(v))
}

// -----------------------------------------------------------------------------
// 字段访问部分
// -----------------------------------------------------------------------------

// GetField 通过字段名获取结构体字段的值，支持嵌入式字段
func GetField(obj interface{}, fieldName string) (func() any, error) {
	if obj == nil {
		return nil, fmt.Errorf("对象不能为空")
	}

	// 获取对象的反射值
	objValue := reflect.ValueOf(obj)

	// 如果传入的是指针，则获取其元素
	if objValue.Kind() == reflect.Ptr {
		objValue = objValue.Elem()
	}

	// 只能处理结构体
	if objValue.Kind() != reflect.Struct {
		return nil, fmt.Errorf("对象必须是结构体或结构体指针")
	}

	// 获取类型信息
	typeInfo := GetTypeInfoFromInterface(obj)
	if typeInfo.IsPtr {
		typeInfo = typeInfo.ElemTypeInfo
	}

	// 查找字段（包括嵌入式字段）
	fieldInfo, ok := typeInfo.Fields[fieldName]
	if !ok {
		return nil, fmt.Errorf("字段 %s 不存在", fieldName)
	}

	// 获取指向结构体实例的指针
	var objPtr unsafe.Pointer
	if objValue.CanAddr() {
		objPtr = unsafe.Pointer(objValue.UnsafeAddr())
	} else {
		ptr := reflect.New(objValue.Type())
		ptr.Elem().Set(objValue)
		// objPtr = unsafe.Pointer(objValue.Pointer())
		objPtr = ptr.UnsafePointer()
	}

	// 使用偏移量获取字段地址
	fieldPtr := unsafe.Pointer(uintptr(objPtr) + fieldInfo.Offset)

	// 根据字段类型创建反射值
	fieldValue := reflect.NewAt(fieldInfo.Type, fieldPtr).Elem()

	// 返回接口值
	return func() any {
		return fieldValue.Interface()
	}, nil
}

// SetField 通过字段名设置结构体字段的值，支持嵌入式字段
func SetField(obj interface{}, fieldName string, value interface{}) error {
	if obj == nil {
		return fmt.Errorf("对象不能为空")
	}

	// 获取对象的反射值
	objValue := reflect.ValueOf(obj)

	// 必须是指针才能修改
	if objValue.Kind() != reflect.Ptr {
		return fmt.Errorf("对象必须是指针才能修改字段")
	}

	// 获取指针指向的元素
	objElem := objValue.Elem()

	// 只能处理结构体
	if objElem.Kind() != reflect.Struct {
		return fmt.Errorf("对象必须是结构体指针")
	}

	// 获取类型信息
	typeInfo := GetTypeInfoFromInterface(obj)
	if !typeInfo.IsPtr {
		return fmt.Errorf("内部错误: 类型应该是指针")
	}

	elemTypeInfo := typeInfo.ElemTypeInfo
	if elemTypeInfo == nil {
		return fmt.Errorf("无法获取元素类型信息")
	}

	// 查找字段（包括嵌入式字段）
	fieldInfo, ok := elemTypeInfo.Fields[fieldName]
	if !ok {
		return fmt.Errorf("字段 %s 不存在", fieldName)
	}

	// 创建新值的反射值
	newValue := reflect.ValueOf(value)

	// 检查类型兼容性
	if !newValue.Type().AssignableTo(fieldInfo.Type) {
		if newValue.Type().ConvertibleTo(fieldInfo.Type) {
			newValue = newValue.Convert(fieldInfo.Type)
		} else {
			return fmt.Errorf("类型不匹配: 不能将 %s 类型赋值给 %s 类型",
				newValue.Type().String(), fieldInfo.Type.String())
		}
	}

	// 获取指向结构体实例的指针
	objPtr := unsafe.Pointer(objElem.UnsafeAddr())

	// 使用偏移量获取字段地址
	fieldPtr := unsafe.Pointer(uintptr(objPtr) + fieldInfo.Offset)

	// 直接使用unsafe设置字段值
	switch fieldInfo.Type.Kind() {
	case reflect.Bool:
		*(*bool)(fieldPtr) = newValue.Bool()
	case reflect.Int:
		*(*int)(fieldPtr) = int(newValue.Int())
	case reflect.Int8:
		*(*int8)(fieldPtr) = int8(newValue.Int())
	case reflect.Int16:
		*(*int16)(fieldPtr) = int16(newValue.Int())
	case reflect.Int32:
		*(*int32)(fieldPtr) = int32(newValue.Int())
	case reflect.Int64:
		*(*int64)(fieldPtr) = newValue.Int()
	case reflect.Uint:
		*(*uint)(fieldPtr) = uint(newValue.Uint())
	case reflect.Uint8:
		*(*uint8)(fieldPtr) = uint8(newValue.Uint())
	case reflect.Uint16:
		*(*uint16)(fieldPtr) = uint16(newValue.Uint())
	case reflect.Uint32:
		*(*uint32)(fieldPtr) = uint32(newValue.Uint())
	case reflect.Uint64:
		*(*uint64)(fieldPtr) = newValue.Uint()
	case reflect.Uintptr:
		*(*uintptr)(fieldPtr) = uintptr(newValue.Uint())
	case reflect.Float32:
		*(*float32)(fieldPtr) = float32(newValue.Float())
	case reflect.Float64:
		*(*float64)(fieldPtr) = newValue.Float()
	case reflect.Complex64:
		*(*complex64)(fieldPtr) = complex64(newValue.Complex())
	case reflect.Complex128:
		*(*complex128)(fieldPtr) = newValue.Complex()
	case reflect.String:
		*(*string)(fieldPtr) = newValue.String()
	default:
		// 对于结构体、数组、切片、映射等复杂类型，使用memmove
		// 获取新值的指针
		valuePtr := unsafe.Pointer(newValue.UnsafeAddr())
		// 获取类型大小
		typeSize := fieldInfo.Type.Size()
		// 内存拷贝
		memmove(fieldPtr, valuePtr, typeSize)
	}

	return nil
}

// memmove 实现内存拷贝
func memmove(dst, src unsafe.Pointer, size uintptr) {
	typeMemmove(dst, src, size)
}

// typeMemmove 内联汇编实现内存拷贝
//
//go:noinline
//go:linkname typeMemmove runtime.memmove
func typeMemmove(dst, src unsafe.Pointer, size uintptr)

// GetFieldByPath 通过字段路径获取多层嵌套结构体中的字段值
func GetFieldByPath(obj interface{}, fieldPath []string) (interface{}, error) {
	if obj == nil {
		return nil, fmt.Errorf("对象不能为空")
	}

	if len(fieldPath) == 0 {
		return nil, fmt.Errorf("字段路径不能为空")
	}

	if len(fieldPath) == 1 {
		// 单一字段直接调用GetField
		return GetField(obj, fieldPath[0])
	}

	// 多层字段递归处理
	current := obj

	// 获取除最后一个字段外的所有中间字段
	for i := 0; i < len(fieldPath)-1; i++ {
		fieldValue, err := GetField(current, fieldPath[i])
		if err != nil {
			return nil, fmt.Errorf("获取字段路径 %s 出错: %w", fieldPath[i], err)
		}
		current = fieldValue
	}

	// 获取最后一个字段
	return GetField(current, fieldPath[len(fieldPath)-1])
}

// SetFieldByPath 通过字段路径设置多层嵌套结构体中的字段值
func SetFieldByPath(obj interface{}, fieldPath []string, value interface{}) error {
	if obj == nil {
		return fmt.Errorf("对象不能为空")
	}

	if len(fieldPath) == 0 {
		return fmt.Errorf("字段路径不能为空")
	}

	if len(fieldPath) == 1 {
		// 单一字段直接调用SetField
		return SetField(obj, fieldPath[0], value)
	}

	// 获取中间嵌套结构体
	current := obj

	// 获取除最后一个字段外的所有中间字段的指针
	for i := 0; i < len(fieldPath)-1; i++ {
		fieldName := fieldPath[i]
		fieldValue, err := GetField(current, fieldName)
		if err != nil {
			return fmt.Errorf("获取字段路径 %s 出错: %w", fieldName, err)
		}

		// 确保中间字段是指针或可寻址的结构体
		fieldReflectValue := reflect.ValueOf(fieldValue)
		if fieldReflectValue.Kind() != reflect.Ptr {
			// 如果不是指针，获取当前字段的地址
			objValue := reflect.ValueOf(current)
			if objValue.Kind() == reflect.Ptr {
				objValue = objValue.Elem()
			}

			field := objValue.FieldByName(fieldName)
			if !field.IsValid() {
				return fmt.Errorf("字段 %s 不存在或不可访问", fieldName)
			}

			if !field.CanAddr() {
				return fmt.Errorf("字段 %s 不可寻址", fieldName)
			}

			// 获取字段地址
			current = field.Addr().Interface()
		} else {
			current = fieldValue
		}
	}

	// 设置最后一个字段
	return SetField(current, fieldPath[len(fieldPath)-1], value)
}

// -----------------------------------------------------------------------------
// 方法调用部分
// -----------------------------------------------------------------------------

// CallMethod 调用对象的方法
func CallMethod(obj interface{}, methodName string, args ...interface{}) ([]interface{}, error) {
	if obj == nil {
		return nil, fmt.Errorf("对象不能为空")
	}

	// 获取对象的类型信息
	objType := reflect.TypeOf(obj)
	objValue := reflect.ValueOf(obj)
	isPtr := objType.Kind() == reflect.Ptr

	// 获取缓存的类型信息
	typeInfo := GetTypeInfoFromInterface(obj)

	// 先查找方法（优先查找接收器类型匹配的方法）
	var methodInfo *MethodInfo
	var ok bool

	// 如果对象是指针类型，优先查找指针接收器方法
	if isPtr {
		methodInfo, ok = typeInfo.Methods[methodName]
		if !ok {
			// 如果在指针类型中没找到，尝试在元素类型中查找
			if typeInfo.ElemTypeInfo != nil {
				methodInfo, ok = typeInfo.ElemTypeInfo.Methods[methodName]
			}
		}
	} else {
		// 如果对象是值类型，优先查找值接收器方法
		methodInfo, ok = typeInfo.Methods[methodName]
		if !ok {
			// 如果在值类型中没找到，尝试在指针方法中查找
			methodInfo, ok = typeInfo.PtrMethods[methodName]
			if ok {
				// 如果在指针方法中找到，需要获取对象的指针
				if objValue.CanAddr() {
					objValue = objValue.Addr()
				} else {
					return nil, fmt.Errorf("无法获取不可寻址值的指针方法：%s", methodName)
				}
			}
		}
	}

	if !ok || methodInfo == nil {
		return nil, fmt.Errorf("方法 %s 不存在", methodName)
	}

	// 获取方法
	method := objValue.MethodByName(methodName)
	if !method.IsValid() {
		return nil, fmt.Errorf("无法获取方法 %s", methodName)
	}

	// 获取方法类型和可变参数标志
	methodType := methodInfo.Type
	isVariadic := methodInfo.IsVariadic

	// 检查参数数量
	if !isVariadic && len(args) != methodInfo.NumIn {
		return nil, fmt.Errorf("方法 %s 需要 %d 个参数，但提供了 %d 个",
			methodName, methodInfo.NumIn, len(args))
	} else if isVariadic && len(args) < methodInfo.NumIn-1 {
		// 对于可变参数函数，参数数量至少应该是非可变参数的数量
		return nil, fmt.Errorf("方法 %s 至少需要 %d 个参数，但提供了 %d 个",
			methodName, methodInfo.NumIn-1, len(args))
	}

	// 构建参数列表
	var in []reflect.Value

	if !isVariadic {
		// 非可变参数方法调用
		in = make([]reflect.Value, len(args))

		for i, arg := range args {
			argType := methodType.In(i + 1) // +1 跳过接收器参数
			argValue := reflect.ValueOf(arg)

			// 类型检查和转换
			if !argValue.Type().AssignableTo(argType) {
				if argValue.Type().ConvertibleTo(argType) {
					argValue = argValue.Convert(argType)
				} else {
					return nil, fmt.Errorf("参数 %d 类型不匹配: 期望 %s，得到 %s",
						i, argType.String(), argValue.Type().String())
				}
			}

			in[i] = argValue
		}

		// 调用普通方法
		results := method.Call(in)

		// 将结果转换为 interface{} 切片
		out := make([]interface{}, len(results))
		for i, result := range results {
			out[i] = result.Interface()
		}

		return out, nil
	} else {
		// 可变参数方法调用
		numFixedArgs := methodInfo.NumIn - 1 // 固定参数数量（不包括可变参数）

		// 处理固定参数
		in = make([]reflect.Value, len(args))
		for i := 0; i < len(args); i++ {
			if i < numFixedArgs {
				// 固定参数
				argType := methodType.In(i + 1) // +1 跳过接收器参数
				argValue := reflect.ValueOf(args[i])

				// 类型检查和转换
				if !argValue.Type().AssignableTo(argType) {
					if argValue.Type().ConvertibleTo(argType) {
						argValue = argValue.Convert(argType)
					} else {
						return nil, fmt.Errorf("参数 %d 类型不匹配: 期望 %s，得到 %s",
							i, argType.String(), argValue.Type().String())
					}
				}

				in[i] = argValue
			} else {
				// 可变参数
				varArgType := methodType.In(numFixedArgs + 1).Elem() // 获取可变参数的元素类型
				argValue := reflect.ValueOf(args[i])

				// 类型检查和转换
				if !argValue.Type().AssignableTo(varArgType) {
					if argValue.Type().ConvertibleTo(varArgType) {
						argValue = argValue.Convert(varArgType)
					} else {
						return nil, fmt.Errorf("可变参数 %d 类型不匹配: 期望 %s，得到 %s",
							i-numFixedArgs, varArgType.String(), argValue.Type().String())
					}
				}

				in[i] = argValue
			}
		}

		// 调用可变参数方法
		var results []reflect.Value
		results = method.Call(in) // 使用普通Call调用，让Go处理可变参数展开

		// 将结果转换为 interface{} 切片
		out := make([]interface{}, len(results))
		for i, result := range results {
			out[i] = result.Interface()
		}

		return out, nil
	}
}

// FindMethodByPrefix 查找具有指定前缀的方法
func FindMethodByPrefix(obj interface{}, prefix string) []string {
	if obj == nil {
		return nil
	}

	// 获取缓存的类型信息
	typeInfo := GetTypeInfoFromInterface(obj)

	var methods []string

	// 检查值接收器方法
	for name := range typeInfo.Methods {
		if len(prefix) == 0 || hasPrefix(name, prefix) {
			methods = append(methods, name)
		}
	}

	// 如果是指针类型，检查元素类型的方法
	if typeInfo.IsPtr && typeInfo.ElemTypeInfo != nil {
		for name := range typeInfo.ElemTypeInfo.Methods {
			// 避免重复添加
			if !contains(methods, name) && (len(prefix) == 0 || hasPrefix(name, prefix)) {
				methods = append(methods, name)
			}
		}
	} else {
		// 如果是值类型，检查指针方法
		for name := range typeInfo.PtrMethods {
			if !contains(methods, name) && (len(prefix) == 0 || hasPrefix(name, prefix)) {
				methods = append(methods, name)
			}
		}
	}

	return methods
}

// ListMethods 列出对象的所有方法
func ListMethods(obj interface{}) ([]string, error) {
	if obj == nil {
		return nil, fmt.Errorf("对象不能为空")
	}

	return FindMethodByPrefix(obj, ""), nil
}

// GetMethodInfo 获取方法的详细信息
func GetMethodInfo(obj interface{}, methodName string) (*MethodInfo, error) {
	if obj == nil {
		return nil, fmt.Errorf("对象不能为空")
	}

	// 获取缓存的类型信息
	typeInfo := GetTypeInfoFromInterface(obj)

	// 先在值接收器方法中查找
	if methodInfo, ok := typeInfo.Methods[methodName]; ok {
		return methodInfo, nil
	}

	// 如果是指针类型，检查元素类型的方法
	if typeInfo.IsPtr && typeInfo.ElemTypeInfo != nil {
		if methodInfo, ok := typeInfo.ElemTypeInfo.Methods[methodName]; ok {
			return methodInfo, nil
		}
	} else {
		// 如果是值类型，检查指针方法
		if methodInfo, ok := typeInfo.PtrMethods[methodName]; ok {
			return methodInfo, nil
		}
	}

	return nil, fmt.Errorf("方法 %s 不存在", methodName)
}

// 辅助函数：检查字符串是否有指定前缀（忽略大小写）
func hasPrefix(s, prefix string) bool {
	if len(s) < len(prefix) {
		return false
	}

	for i := 0; i < len(prefix); i++ {
		if lowerChar(s[i]) != lowerChar(prefix[i]) {
			return false
		}
	}

	return true
}

// 辅助函数：转换字符为小写
func lowerChar(c byte) byte {
	if c >= 'A' && c <= 'Z' {
		return c + ('a' - 'A')
	}
	return c
}

// 辅助函数：检查切片是否包含字符串
func contains(slice []string, s string) bool {
	for _, item := range slice {
		if item == s {
			return true
		}
	}
	return false
}

// -----------------------------------------------------------------------------
// 直接函数调用部分
// -----------------------------------------------------------------------------
// CallMethodFast 优化的方法调用，使用类型缓存和函数指针提高性能
func CallMethodFast(obj interface{}, methodName string, args ...interface{}) ([]interface{}, error) {
	if obj == nil {
		return nil, fmt.Errorf("对象不能为空")
	}

	// 获取对象的类型信息
	objType := reflect.TypeOf(obj)
	objValue := reflect.ValueOf(obj)
	isPtr := objType.Kind() == reflect.Ptr

	// 获取缓存的类型信息
	typeInfo := GetTypeInfoFromInterface(obj)

	// 查找方法
	var methodInfo *MethodInfo
	var ok bool

	// 查找方法信息（与CallMethod相同的查找逻辑）
	if isPtr {
		methodInfo, ok = typeInfo.Methods[methodName]
		if !ok && typeInfo.ElemTypeInfo != nil {
			methodInfo, ok = typeInfo.ElemTypeInfo.Methods[methodName]
		}
	} else {
		methodInfo, ok = typeInfo.Methods[methodName]
		if !ok {
			methodInfo, ok = typeInfo.PtrMethods[methodName]
			if ok {
				if objValue.CanAddr() {
					objValue = objValue.Addr()
				} else {
					return nil, fmt.Errorf("无法获取不可寻址值的指针方法：%s", methodName)
				}
			}
		}
	}

	if !ok || methodInfo == nil {
		return nil, fmt.Errorf("方法 %s 不存在", methodName)
	}

	// 参数数量检查
	isVariadic := methodInfo.IsVariadic
	if !isVariadic && len(args) != methodInfo.NumIn {
		return nil, fmt.Errorf("方法 %s 需要 %d 个参数，但提供了 %d 个",
			methodName, methodInfo.NumIn, len(args))
	} else if isVariadic && len(args) < methodInfo.NumIn-1 {
		return nil, fmt.Errorf("方法 %s 至少需要 %d 个参数，但提供了 %d 个",
			methodName, methodInfo.NumIn-1, len(args))
	}

	// 直接使用已缓存的方法索引获取方法值
	method := objValue.Method(methodInfo.Index)

	// 准备参数，与CallMethod一致处理类型兼容性
	in := make([]reflect.Value, len(args))
	methodType := methodInfo.Type

	for i, arg := range args {
		argValue := reflect.ValueOf(arg)

		// 根据参数位置确定期望类型
		var expectedType reflect.Type
		if isVariadic && i >= methodInfo.NumIn-1 {
			// 可变参数部分，使用可变参数切片的元素类型
			expectedType = methodType.In(methodInfo.NumIn).Elem()
		} else {
			// 固定参数部分
			expectedType = methodType.In(i + 1) // +1 跳过接收器
		}

		// 类型检查和转换
		if !argValue.Type().AssignableTo(expectedType) {
			if argValue.Type().ConvertibleTo(expectedType) {
				argValue = argValue.Convert(expectedType)
			} else {
				return nil, fmt.Errorf("参数 %d 类型不匹配: 期望 %s，得到 %s",
					i, expectedType.String(), argValue.Type().String())
			}
		}

		in[i] = argValue
	}

	// 调用方法
	results := method.Call(in)

	// 处理返回值
	out := make([]interface{}, len(results))
	for i, result := range results {
		out[i] = result.Interface()
	}

	return out, nil
}
